home *** CD-ROM | disk | FTP | other *** search
/ Fritz: All Fritz / All Fritz.zip / All Fritz / FILES / PROGBLER / A86V318B.LZH / A07.DOC < prev    next >
Text File  |  1988-05-20  |  20KB  |  452 lines
  1. CHAPTER 7   THE FLOATING-POINT PROCESSOR
  2.  
  3.  
  4. In this chapter, we'll refer to the various Central Processing
  5. Units (CPUs) as the "86".  Thus "86" refers to either the 8088,
  6. 8086, 80186, 80286, etc.  We'll refer to the various coprocessors
  7. as the "87".  Thus "87" refers to either the 8087 or the 287.
  8.  
  9.  
  10. The 8087 and 287 Coprocessors
  11.  
  12. All IBM-PC's, and most clones, contain a socket for a floating
  13. point coprocessor.  If you shell out between $80 and $300, and
  14. plug the appropriate chip into that socket, then a host of
  15. floating point instructions is added to the assembly language
  16. instruction set.
  17.  
  18. The original IBM-PC, and the XT, accept the original floating
  19. point chip, the 8087.  The AT accepts a later update, the 287.
  20. From a programming standpoint, the two chips are nearly
  21. identical: the 287 adds the instructions FSETPM and FSTSW AX, and
  22. ignores the instructions FENI and FDISI.  There is, however, a
  23. rather nasty design flaw in the 8087, that was corrected in the
  24. 287.
  25.  
  26. To understand the flaw, you must understand how the 86 and 87
  27. work as coprocessors. Whenever the 86 sees a floating point
  28. instruction, it communicates the instruction, and any associated
  29. memory operands, to the 87.  Then the 86 goes on to its next
  30. instruction, operating in parallel with the 87.  That's OK, so
  31. long as the following instructions don't do one of the following:
  32.  
  33.   1. Execute another floating point instruction; or
  34.  
  35.   2. Try to read the results of the still-executing floating
  36.      point instruction.
  37.  
  38. If they do, then you must provide an instruction called WAIT (or
  39. synonymously FWAIT), which halts the 86 until the 87 is finished.
  40. For almost all floating point instructions, it should not be
  41. necessary to provide an explicit FWAIT; the 86 ought to know that
  42. it should wait.  For the 8087, it IS necessary to give an
  43. explicit FWAIT before each floating point instruction: that is
  44. the flaw.
  45.  
  46. Because of the flaw, all assemblers supporting the 8087 will
  47. silently insert an FWAIT code (hex 9B) before all 87
  48. instructions, except those few (the FN instructions other than
  49. FNOP) not requiring the FWAIT.  A86 provides the switch +F (the F
  50. must be capitalized), to signal that the 287 is the target
  51. processor.  A86 also provides the directive ".287", compatible
  52. with Microsoft's assembler, that you can insert into your
  53. programs to accomplish the same thing as +F. However, the actions
  54. taken by A86 and Microsoft when seeing .287 are completely
  55. disjoint!  To wit:
  56.  
  57. * A86 ceases outputting FWAIT directives that are unnecessary for
  58.   the 287.  For reasons beyond my comprehension, Microsoft
  59.   continues to put them out.  Can someone enlighten me as to why
  60.   Microsoft is putting out those codes?
  61.                                                               7-2
  62.  
  63. * A86 ignores the instructions FENI, FDISI, FNENI, and FNDISI
  64.   after it sees a .287 directive.  Microsoft continues to
  65.   assemble these instructions.
  66.  
  67. * Microsoft recognizes the new 287 instructions, if and only if
  68.   it sees the .287 directive.  A86 recognizes them even if .287
  69.   is not given.  In general, I don't attempt to police your
  70.   instruction usage-- if you use an instruction available on a
  71.   limited number of processors, I trust that you are programming
  72.   for one of those processors.
  73.  
  74. In summary, if your program will be running only on machines with
  75. a 287, you can give ".287" directive. Your programs will be
  76. significantly shorter than if they were assembled by Microsoft.
  77. If you want your programs to run on all machines containing a
  78. floating point chip, you should refrain from specifying .287.
  79.  
  80. WARNING: The most common mistake 87 programmers make is to try to
  81. read the results of an 87 operation in 86 memory, before the
  82. results are ready.  At least on my AT, the system often crashes
  83. when you do this!  If your program runs correctly when single
  84. stepped, but crashes when set loose, then chances are you need an
  85. extra explicit FWAIT somewhere.
  86.  
  87.  
  88. Emulating the 8087 by Software
  89.  
  90. There is a software package provided with many compilers
  91. (Borland's Turbo C and most Microsoft compilers, for example)
  92. that emulates the 8087 instruction set.  The emulator is very
  93. cleverly implemented so that the programmer need not know whether
  94. a floating point chip will be available, or whether emulation
  95. will be necessary.  This is done by having the linker replace all
  96. floating point machine instructions with INT calls to certain
  97. interrupts, dedicated to emulation.  The interrupt handlers
  98. interpret the operands to the instructions, and emulate the 8087.
  99.  
  100. You can tell A86 that the emulator might be used, by providing a
  101. +f switch in the invocation line, or in the A86 environment
  102. variable (make sure the f is lower case).  Since your program
  103. will be linked to the emulator, you must be producing an OBJ
  104. file, not a COM file, for emulation support to take effect.
  105. Whenever a floating point instruction is assembled, A86 will
  106. generate an external reference at the opcode for the instruction.
  107. Then, if the emulation package is linked with your program, the
  108. opcodes will be replaced by the INT calls. If a special
  109. non-emulation module is linked, the opcodes will be left alone,
  110. and the floating point instructions will be executed directly.
  111.                                                               7-3
  112.  
  113. The Floating Point Stack
  114.  
  115. The 87 has its own register set, of 8 floating point numbers
  116. occupying 10 bytes each, plus 14 bytes of status and control
  117. information.  Many of the 87's instructions cause the numbers to
  118. act like a stack, much like a Hewlett-Packard calculator.  For
  119. this reason, the numbers are called the floating point stack.
  120.  
  121. The standard name for the top element of the floating point stack
  122. is either ST or ST(0); the others are named ST(1) through ST(7).
  123. Thus, for example, the instruction to add stack element number 3
  124. into the top stack element is usually coded FADD ST,ST(3).
  125.  
  126. I find this notation painfully verbose.  Especially bad are the
  127. parentheses, which are hard to type, and which add visual clutter
  128. to the program.  To alleviate this problem while retaining
  129. language compatibility, I name my stack elements simply 0 through
  130. 7.  I recognize ST as a synonym for 0.  I allow expression
  131. elements to be concatenated; concatenation is the same as
  132. addition.  Thus, when A86 sees ST(3), it computes 0+3 = 3.  So
  133. you can code the old way, FADD ST,ST(3), or you can code the
  134. concise way, FADD 0,3 or simply FADD 3.
  135.  
  136.  
  137. Floating Point Initializations
  138.  
  139. In general, you use the 87 by loading numbers from 86 memory to
  140. the 87 stack (using FLD instructions), calculating on the 87
  141. stack, and storing the results back to 86 memory (using FST and
  142. FSTP instructions).  There are seven constant numbers built into
  143. the 87 instruction set: zero, one, Pi, and four logarithmic
  144. conversion constants.  These can be loaded using the FLD0, FLD1,
  145. FLDPI, FLDL2T, FLDL2E, FLDLG2, and FLDLN2 instructions.  All
  146. other constants must be declared in, then loaded from, 86 memory.
  147. Integer constant words and doublewords can be loaded via FILD.
  148. Non-integer constant doubleword, quadwords, and ten-byte numbers
  149. can be loaded via FLD.
  150.  
  151. A86 allows you to declare constants loaded via FLD as floating
  152. point numbers, using scientific notation if you like.  As an
  153. exclusive feature, A86 allows you to use any of the 4 arithmetic
  154. functions +, -, *, / in expressions involving floating point
  155. numbers.  A86 will even do type conversion if one of the two
  156. operands is given as an integer; though for clarity I recommend
  157. that you always give floating point constants with their decimal
  158. point.
  159.  
  160.  
  161. Built-In Constant Names
  162.  
  163. A86 offers another exclusive feature: the built-in symbols
  164.  
  165.     PI   ratio of circumference to diameter of a circle
  166.  
  167.     L2T  log base 2 of 10
  168.  
  169.     L2E  log base 2 of the calculus constant e = 2.71828...
  170.                                                               7-4
  171.  
  172.     LG2  log base 10 of 2
  173.  
  174.     LN2  natural log (base e) of 2
  175.  
  176. You can use these symbols in expressions, to declare useful
  177. constants.  For example, you can declare the degrees-to-radians
  178. conversion constant:
  179.  
  180.     DEG_TO_RAD  DT  PI/180.
  181.  
  182.  
  183.  
  184. Special Immediate FLD Form
  185.  
  186. Yet another exclusive A86 feature is the instruction form FLD
  187. constant.  This form is intended primarily to facilitate "fooling
  188. around" with the 87 when using D86; but it is also useful for
  189. quick-and-dirty programs.  For example, the instruction FLD 12.3
  190. generates the following sequence of code bytes (without
  191. explicitly using the local labels given):
  192.  
  193.     CS FLD T[M1]
  194.     JMP >M2
  195.   M1  DT 12.3
  196.   M2:
  197.  
  198. Obviously, this form is not terrifically efficient: you can
  199. always save the JMP by placing the constant outside of the
  200. instruction stream; and the CS override might not be needed.  But
  201. the form is very, very convenient!
  202.  
  203. NOTE that the preceding 2 sections imply that you can get
  204. careless and code, for example, FLD PI when you intended FLDPI.
  205. Though the two are functionally equivalent, the first form takes
  206. a whopping 17 bytes; and second, only 2 bytes.  Be careful!
  207.  
  208.  
  209.  
  210. Floating Point Operand Types
  211.  
  212. The list of floating point instructions contains a variety of
  213. operand types.  Here is a brief explanation of those types:
  214.  
  215. 0        stands for the top element of the floating point stack.
  216.          A synonym for 0 is ST or ST(0).
  217.  
  218. i        stands for element number i of the floating point stack.
  219.          i can range from 0 through 7.  A synonym for i is ST(i).
  220.  
  221. mem10r   is a 10-byte memory quantity (typically declared with a
  222.          DT directive) containing a full precision floating point
  223.          number. Intel recommends that you NOT store your numbers
  224.          in full precision; that you use the following double
  225.          precision format instead.  Full precision numbers are
  226.          intended for storage of intermediate results (on the
  227.          stack); they exist to insure maximum accuracy for
  228.          calculations on double precision numbers, which is the
  229.          official external format of 87 numbers.
  230.                                                               7-5
  231.  
  232. mem8r    is an 8-byte memory quantity (typically declared with a
  233.          DQ directive) containing a double precision floating
  234.          point number.  This is the best format for floating
  235.          point numbers on the 87.  The 87 takes the same amount
  236.          of time on double precision calculations as it does on
  237.          single precision.  The only extra time is the memory
  238.          access of 4 more bytes; negligible in comparison to the
  239.          calculation time.
  240.  
  241. mem4r    is a 4-byte quantity (typically defined with a DD
  242.          directive) containing a single precision floating point
  243.          number.
  244.  
  245. mem10d   is a 10-byte quantity (also defined via DT) containing a
  246.          special Binary Coded Decimal format recognized by the
  247.          FBLD and FBSTP instructions.  This format is useful for
  248.          input and output of floating point numbers.
  249.  
  250. mem4i    is a 4-byte quantity representing a signed integer in
  251.          two's-complement notation.
  252.  
  253. mem2i    is a 2-byte quantity representing a signed integer in
  254.          two's-complement notation.
  255.  
  256. mem14    and mem94 are 14- and 94-byte buffers containing the 87
  257.          machine state.
  258.  
  259.  
  260. Operand Choices in A86
  261.  
  262. In the "standard" assembly language, the choice of operands for
  263. floating point instructions seems inconsistent to me.  For
  264. example, to subtract stack i from 0, you must provide two
  265. operands; to do the equivalent comparison, you must provide only
  266. one operand.  A86 smooths out these inconsistencies by allowing
  267. more choices for operands: FADD i is equivalent to FADD 0,i. FCOM
  268. 0,i is equivalent to FCOM i.  The same holds for the other main
  269. arithmetic instructions.  FXCH 0,i and FXCH i,0 are allowed. So
  270. if you wish to retain compatibility with other assemblers, you
  271. should use their more restrictive instruction list, not the
  272. following one.
  273.  
  274.  
  275. The 87 Instruction Set
  276.  
  277. Following is the 87 instruction set.  The "w" in the opcode field
  278. is the FWAIT opcode, hex 9B, which is suppressed if .287 is
  279. selected.  Again, "0", "1", and "i" stand for the associated
  280. floating point stack registers, not constant numbers!  Constant
  281. numbers in the descriptions are given with decimal points: 0.0,
  282. 1.0, 2.0, 10.0.
  283.                                                               7-6
  284.  
  285.  
  286.  
  287.     Opcode    Instruction     Description
  288.  
  289.  w  D9 F0     F2XM1           0 := (2.0 ** 0) - 1.0
  290.  w  D9 E1     FABS            0 := |0|
  291.  w  DE C1     FADD            1 := 1 + 0, pop
  292.  w  D8 C0+i   FADD i          0 := i + 0
  293.  w  DC C0+i   FADD i,0        i := i + 0
  294.  w  D8 C0+i   FADD 0,i        0 := i + 0
  295.  w  D8 /0     FADD mem4r      0 := 0 + mem4r
  296.  w  DC /0     FADD mem8r      0 := 0 + mem8r
  297.  w  DE C0+i   FADDP i,0       i := i + 0, pop
  298.  w  DF /4     FBLD mem10d     push, 0 := mem10d
  299.  w  DF /6     FBSTP mem10d    mem10d := 0, pop
  300.  
  301.  w  D9 E0     FCHS            0 := -0
  302. 9B  DB E2     FCLEX           clear exceptions
  303.  w  D8 D1     FCOM            compare 0 - 1
  304.  w  D8 D0+i   FCOM 0,i        compare 0 - i
  305.  w  D8 D0+i   FCOM i          compare 0 - i
  306.  w  D8 /2     FCOM mem4r      compare 0 - mem4r
  307.  w  DC /2     FCOM mem8r      compare 0 - mem8r
  308.  w  D8 D9     FCOMP           compare 0 - 1, pop
  309.  w  D8 D8+i   FCOMP 0,i       compare 0 - i, pop
  310.  w  D8 D8+i   FCOMP i         compare 0 - i, pop
  311.  w  D8 /3     FCOMP mem4r     compare 0 - mem4r, pop
  312.  w  DC /3     FCOMP mem8r     compare 0 - mem8r, pop
  313.  w  DE D9     FCOMPP          compare 0 - 1, pop both
  314.  
  315.  w  D9 F6     FDECSTP         decrement stack pointer
  316.  w  DB E1     FDISI           disable interrupts (.287 ignore)
  317.  
  318.  w  DE F9     FDIV            1 := 1 / 0, pop
  319.  w  D8 F0+i   FDIV i          0 := 0 / i
  320.  w  DC F8+i   FDIV i,0        i := i / 0
  321.  w  D8 F0+i   FDIV 0,i        0 := 0 / i
  322.  w  D8 /6     FDIV mem4r      0 := 0 / mem4r
  323.  w  DC /6     FDIV mem8r      0 := 0 / mem8r
  324.  
  325.  w  DE F8+i   FDIVP i,0       i := i / 0, pop
  326.  w  DE F1     FDIVR           1 := 0 / 1, pop
  327.  w  D8 F8+i   FDIVR i         0 := i / 0
  328.  w  DC F0+i   FDIVR i,0       i := 0 / i
  329.  w  D8 F8+i   FDIVR 0,i       0 := i / 0
  330.  w  D8 /7     FDIVR mem4r     0 := mem4r / 0
  331.  w  DC /7     FDIVR mem8r     0 := mem8r / 0
  332.  w  DE F0+i   FDIVRP i,0      i := 0 / i, pop
  333.  
  334.  w  DB E0     FENI            enable interrupts (.287 ignore)
  335.  w  DD C0+i   FFREE i         empty i
  336.  w  DE /0     FIADD mem2i     0 := 0 + mem4i
  337.  w  DA /0     FIADD mem4i     0 := 0 + mem2i
  338.  w  DE /2     FICOM mem2i     compare 0 - mem2i
  339.  w  DA /2     FICOM mem4i     compare 0 - mem4i
  340.  w  DE /3     FICOMP mem2i    compare 0 - mem2i, pop
  341.  w  DA /3     FICOMP mem4i    compare 0 - mem4i, pop
  342.                                                               7-7
  343.  
  344.  w  DE /6     FIDIV mem2i     0 := 0 / mem2i
  345.  w  DA /6     FIDIV mem4i     0 := 0 / mem4i
  346.  w  DE /7     FIDIVR mem2i    0 := mem2i / 0
  347.  w  DA /7     FIDIVR mem4i    0 := mem4i / 0
  348.  w  DF /0     FILD mem2i      push, 0 := mem2i
  349.  w  DB /0     FILD mem4i      push, 0 := mem4i
  350.  w  DF /5     FILD mem8i      push, 0 := mem8i
  351.  
  352.  w  DE /1     FIMUL mem2i     0 := 0 * mem2i
  353.  w  DA /1     FIMUL mem4i     0 := 0 * mem4i
  354.  w  D9 F7     FINCSTP         increment stack pointer
  355. 9B  DB E3     FINIT           initialize 87
  356.  w  DF /2     FIST mem2i      mem2i := 0
  357.  w  DB /2     FIST mem4i      mem4i := 0
  358.  w  DF /3     FISTP mem2i     mem2i := 0, pop
  359.  w  DB /3     FISTP mem4i     mem4i := 0, pop
  360.  w  DF /7     FISTP mem8i     mem8i := 0, pop
  361.  
  362.  w  DE /4     FISUB mem2i     0 := 0 - mem2i
  363.  w  DA /4     FISUB mem4i     0 := 0 - mem4i
  364.  w  DE /5     FISUBR mem2i    0 := mem2i - 0
  365.  w  DA /5     FISUBR mem4i    0 := mem4i - 0
  366.  
  367.  
  368.  
  369.  w  D9 C0+i   FLD i           push, 0 := old i
  370.  w  DB /5     FLD mem10r      push, 0 := mem10r
  371.  w  D9 /0     FLD mem4r       push, 0 := mem4r
  372.  w  DD /0     FLD mem8r       push, 0 := mem8r
  373.  w  D9 E8     FLD1            push, 0 := 1.0
  374.  w  D9 /5     FLDCW mem2i     control word := mem2i
  375.  w  D9 /4     FLDENV mem14    environment := mem14
  376.  w  D9 EA     FLDL2E          push, 0 := log base 2.0 of e
  377.  w  D9 E9     FLDL2T          push, 0 := log base 2.0 of 10.0
  378.  w  D9 EC     FLDLG2          push, 0 := log base 10.0 of 2.0
  379.  w  D9 ED     FLDLN2          push, 0 := log base e of 2.0
  380.  w  D9 EB     FLDPI           push, 0 := Pi
  381.  w  D9 EE     FLDZ            push, 0 := +0.0
  382.  
  383.  w  DE C9     FMUL            1 := 1 * 0, pop
  384.  w  D8 C8+i   FMUL i          0 := 0 * i
  385.  w  DC C8+i   FMUL i,0        i := i * 0
  386.  w  D8 C8+i   FMUL 0,i        0 := 0 * i
  387.  w  D8 /1     FMUL mem4r      0 := 0 * mem4r
  388.  w  DC /1     FMUL mem8r      0 := 0 * mem8r
  389.  w  DE C8+i   FMULP i,0       i := i * 0, pop
  390.  
  391.     DB E2     FNCLEX          nowait clear exceptions
  392.     DB E1     FNDISI          disable interrupts (.287 ignore)
  393.     DB E0     FNENI           enable interrupts (.287 ignore)
  394.     DB E3     FNINIT          nowait initialize 87
  395.  w  D9 D0     FNOP            no operation
  396.                                                               7-8
  397.  
  398.     DD /6     FNSAVE mem94    mem94 := 87 state
  399.     D9 /7     FNSTCW mem2i    mem2i := control word
  400.     D9 /6     FNSTENV mem14   mem14 := environment
  401.     DF E0     FNSTSW AX       AX := status word
  402.     DD /7     FNSTSW mem2i    mem2i := status word
  403.  w  D9 F3     FPATAN          0 := arctan(1/0), pop
  404.  w  D9 F8     FPREM           0 := REPEAT(0 - 1)
  405.  w  D9 F2     FPTAN           push, 1/0 := tan(old 0)
  406.  
  407.  w  D9 FC     FRNDINT         0 := round(0)
  408.  w  DD /4     FRSTOR mem94    87 state := mem94
  409.  w  DD /6     FSAVE mem94     mem94 := 87 state
  410.  w  D9 FD     FSCALE          0 := 0 * 2.0 ** 1
  411. 9B  DB E4     FSETPM          set protection mode
  412.  w  D9 FA     FSQRT           0 := square root of 0
  413.  
  414.  w  DD D0+i   FST i           i := 0
  415.  w  D9 /2     FST mem4r       mem4r := 0
  416.  w  DD /2     FST mem8r       mem8r := 0
  417.  w  D9 /7     FSTCW mem2i     mem2i := control word
  418.  w  D9 /6     FSTENV mem14    mem14 := environment
  419.  w  DD D8+i   FSTP i          i := 0, pop
  420.  w  DB /7     FSTP mem10r     mem10r := 0, pop
  421.  w  D9 /3     FSTP mem4r      mem4r := 0, pop
  422.  w  DD /3     FSTP mem8r      mem8r := 0, pop
  423.  w  DF E0     FSTSW AX        AX := status word
  424.  w  DD /7     FSTSW mem2i     mem2i := status word
  425.  
  426.  w  DE E9     FSUB            1 := 1 - 0, pop
  427.  w  D8 E0+i   FSUB i          0 := 0 - i
  428.  w  DC E8+i   FSUB i,0        i := i - 0
  429.  w  D8 E0+i   FSUB 0,i        0 := 0 - i
  430.  w  D8 /4     FSUB mem4r      0 := 0 - mem4r
  431.  w  DC /4     FSUB mem8r      0 := 0 - mem8r
  432.  w  DE E8+i   FSUBP i,0       i := i - 0
  433.  w  DE E1     FSUBR           1 := 0 - 1, pop
  434.  w  D8 E8+i   FSUBR i         0 := i - 0
  435.  w  DC E0+i   FSUBR i,0       i := 0 - i
  436.  w  D8 E8+i   FSUBR 0,i       0 := i - 0
  437.  w  D8 /5     FSUBR mem4r     0 := mem4r - 0
  438.  w  DC /5     FSUBR mem8r     0 := mem8r - 0
  439.  w  DE E0+i   FSUBRP i,0      i := 0 - i, pop
  440.  
  441.  w  D9 E4     FTST            compare 0 - 0.0
  442. 9B            FWAIT           wait for 87 ready
  443.  w  D9 E5     FXAM            C3 -- C0 := type of 0
  444.  w  D9 C9     FXCH            exchange 0 and 1
  445.  w  D9 C8+i   FXCH 0,i        exchange 0 and i
  446.  w  D9 C8+i   FXCH i          exchange 0 and i
  447.  w  D9 C8+i   FXCH i,0        exchange 0 and i
  448.  w  D9 F4     FXTRACT         push, 1 := expo, 0 := sig
  449.  w  D9 F1     FYL2X           0 := 1 * log base 2.0 of 0, pop
  450.  w  D9 F9     FYL2XP1         0 := 1 * log base 2.0 of (0+1.0), pop
  451.  
  452.